home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / ip / ka9q / net_src.arc / session.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-05-08  |  9.0 KB  |  446 lines
  1. /* Session control */
  2. #include <stdio.h>
  3. #include "global.h"
  4. #include "config.h"
  5. #include "mbuf.h"
  6. #include "netuser.h"
  7. #include "timer.h"
  8. #include "tcp.h"
  9. #include "ax25.h"
  10. #include "lapb.h"
  11. #include "iface.h"
  12. #include "ftp.h"
  13. #include "telnet.h"
  14. #ifdef _FINGER
  15. #include "finger.h"
  16. #endif
  17. #ifdef NETROM
  18. #include "netrom.h"
  19. #include "nr4.h"
  20. #endif
  21. #include "session.h"
  22. #include "cmdparse.h"
  23.  
  24. struct session *sessions;
  25. struct session *current;
  26. char notval[] = "Not a valid control block\n";
  27. char badsess[] = "Invalid session\n";
  28.  
  29. /* Convert a character string containing a decimal session index number 
  30.  * into a pointer. If the arg is NULLCHAR, use the current default session.
  31.  * If the index is out of range or unused, return NULLSESSION.
  32.  */
  33. static struct session *
  34. sessptr(cp)
  35. char *cp;
  36. {
  37.     register struct session *s;
  38.     unsigned int i;
  39.  
  40.     if(cp == NULLCHAR){
  41.         s = current;
  42.     } else {
  43.         if((i = atoi(cp)) >= nsessions)
  44.             return NULLSESSION;
  45.         s = &sessions[i];
  46.     }
  47.     if(s == NULLSESSION || s->type == FREE)
  48.         return NULLSESSION;
  49.  
  50.     return s;
  51. }
  52.  
  53. /* Select and display sessions */
  54. dosession(argc,argv)
  55. int argc;
  56. char *argv[];
  57. {
  58.     struct session *s;
  59.     extern char *tcpstates[];
  60.     char *psocket();
  61.     extern char *ax25states[];
  62.     char *tcp_port();
  63.  
  64.     if(argc > 1){
  65.         if((current = sessptr(argv[1])) != NULLSESSION)
  66.             go();
  67.         return 0;
  68.     }
  69.     printf(" #       &CB Type   Rcv-Q  State        Remote socket\n");
  70.     for(s=sessions; s < &sessions[nsessions];s++){
  71.         switch(s->type){
  72.         case TELNET:
  73.             printf("%c%-3d%8lx Telnet  %4d  %-13s%-s:%s",
  74.              (current == s)? '*':' ',
  75.              (int)(s - sessions),
  76.              (long)s->cb.telnet->tcb,
  77.              s->cb.telnet->tcb->rcvcnt,
  78.              tcpstates[s->cb.telnet->tcb->state],
  79.              s->name,
  80.              tcp_port(s->cb.telnet->tcb->conn.remote.port));
  81.             break;
  82.         case FTP:
  83.             printf("%c%-3d%8lx FTP     %4d  %-13s%-s:%s",
  84.              (current == s)? '*':' ',
  85.              (int)(s - sessions),
  86.              (long)s->cb.ftp->control,
  87.              s->cb.ftp->control->rcvcnt,
  88.              tcpstates[s->cb.ftp->control->state],
  89.              s->name,
  90.              tcp_port(s->cb.ftp->control->conn.remote.port));
  91.             break;
  92. #ifdef    AX25
  93.         case AX25TNC:
  94.             printf("%c%-3d%8lx AX25    %4d  %-13s%-s",
  95.              (current == s)? '*':' ',
  96.              (int)(s - sessions),
  97.              (long)s->cb.ax25_cb,
  98.             len_mbuf(s->cb.ax25_cb->rxq),
  99.              ax25states[s->cb.ax25_cb->state],
  100.              s->name);
  101.             break;
  102. #endif
  103. #ifdef    _FINGER
  104.         case FINGER:
  105.             printf("%c%-3d%8lx Finger  %4d  %-13s%-s",
  106.              (current == s)? '*':' ',
  107.              (int)(s - sessions),
  108.              (long)s->cb.finger->tcb,
  109.              s->cb.finger->tcb->rcvcnt,
  110.              tcpstates[s->cb.finger->tcb->state],
  111.              s->name, s->cb.finger->tcb->conn.remote.port);
  112.             break;
  113. #endif
  114. #ifdef NETROM
  115.         case NRSESSION:
  116.             printf("%c%-3d%8lx NET/ROM %4d  %-13s%-s",
  117.              (current == s)? '*':' ',
  118.              (int)(s - sessions),
  119.              (long)s->cb.nr4_cb,
  120.             len_mbuf(s->cb.nr4_cb->rxq),
  121.              Nr4states[s->cb.nr4_cb->state],
  122.              s->name);
  123.             break;
  124. #endif
  125.         default:
  126.             continue;
  127.         }
  128.         if(s->rfile != NULLCHAR || s->ufile != NULLCHAR)
  129.             printf("\t");
  130.         if(s->rfile != NULLCHAR)
  131.             printf("Record: %s ",s->rfile);
  132.         if(s->ufile != NULLCHAR)
  133.             printf("Upload: %s",s->ufile);
  134.         printf("\n");
  135.     }
  136.     return 0;
  137. }
  138. /* Enter conversational mode with current session */
  139. int
  140. go()
  141. {
  142.     void rcv_char(),ftpccr(),ax_rx(),fingcli_rcv() ;
  143.  
  144.     if(current == NULLSESSION || current->type == FREE)
  145.         return 0;
  146.     mode = CONV_MODE;
  147.     switch(current->type){
  148.     case TELNET:
  149.         if(current->cb.telnet->remote[TN_ECHO])
  150.             raw();    /* Re-establish raw mode if it was set */
  151.         rcv_char(current->cb.telnet->tcb,0); /* Get any pending input */
  152.         break;
  153.     case FTP:
  154.         ftpccr(current->cb.ftp->control,0);
  155.         break;
  156. #ifdef    AX25
  157.     case AX25TNC:
  158.         ax_rx(current->cb.ax25_cb,0);
  159.         break;
  160. #endif
  161. #ifdef _FINGER
  162.     case FINGER:
  163.         fingcli_rcv(current->cb.finger->tcb,0) ;
  164.         break ;
  165. #endif
  166. #ifdef    NETROM
  167.     case NRSESSION:
  168.         nr4_rx(current->cb.nr4_cb,0) ;
  169.         break ;
  170. #endif
  171.     }
  172.     return 0;
  173. }
  174. doclose(argc,argv)
  175. int argc;
  176. char *argv[];
  177. {
  178.     struct session *s;
  179.  
  180.     if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  181.         printf(badsess);
  182.         return -1;
  183.     }
  184.     switch(s->type){
  185.     case TELNET:
  186.         close_tcp(s->cb.telnet->tcb);
  187.         break;
  188.     case FTP:
  189.         close_tcp(s->cb.ftp->control);
  190.         break;
  191. #ifdef    AX25
  192.     case AX25TNC:
  193.         disc_ax25(s->cb.ax25_cb);
  194.         break;
  195. #endif
  196. #ifdef _FINGER
  197.     case FINGER:
  198.         close_tcp(s->cb.finger->tcb);
  199.         break;
  200. #endif
  201. #ifdef NETROM
  202.     case NRSESSION:
  203.         disc_nr4(s->cb.nr4_cb) ;
  204.         break ;
  205. #endif
  206.     }
  207.     return 0;
  208. }
  209. doreset(argc,argv)
  210. int argc;
  211. char *argv[];
  212. {
  213.     long htol();
  214.     struct session *s;
  215.  
  216.     if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  217.         printf(badsess);
  218.         return -1;
  219.     }
  220.     switch(s->type){
  221.     case TELNET:
  222.         reset_tcp(s->cb.telnet->tcb);
  223.         break;
  224.     case FTP:
  225.         if(s->cb.ftp->data != NULLTCB){
  226.             reset_tcp(s->cb.ftp->data);
  227.             s->cb.ftp->data = NULLTCB;
  228.         }
  229.         reset_tcp(s->cb.ftp->control);
  230.         break;
  231. #ifdef    AX25
  232.     case AX25TNC:
  233.         reset_ax25(s->cb.ax25_cb);
  234.         break;
  235. #endif
  236. #ifdef _FINGER
  237.     case FINGER:
  238.         reset_tcp(s->cb.finger->tcb);
  239.         break;
  240. #endif
  241. #ifdef NETROM
  242.     case NRSESSION:
  243.         reset_nr4(s->cb.nr4_cb) ;
  244.         break ;
  245. #endif
  246.     }
  247.     return 0;
  248. }
  249. int
  250. dokick(argc,argv)
  251. int argc;
  252. char *argv[];
  253. {
  254.     long htol();
  255.     void tcp_timeout();
  256.     struct session *s;
  257.  
  258.     if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  259.         printf(badsess);
  260.         return -1;
  261.     }
  262.     switch(s->type){
  263.     case TELNET:
  264.         if(kick_tcp(s->cb.telnet->tcb) == -1){
  265.             printf(notval);
  266.             return 1;
  267.         }
  268.         break;
  269.     case FTP:
  270.         if(kick_tcp(s->cb.ftp->control) == -1){
  271.  
  272.             printf(notval);
  273.             return 1;
  274.         }
  275.         if(s->cb.ftp->data != NULLTCB)
  276.             kick_tcp(s->cb.ftp->data);
  277.         break;
  278. #ifdef    AX25
  279.     case AX25TNC:
  280.         if(kick_ax25(s->cb.ax25_cb) == -1){
  281.             printf(notval);
  282.             return 1;
  283.         }
  284.         return 1;
  285. #endif
  286. #ifdef _FINGER
  287.     case FINGER:
  288.         if(kick_tcp(s->cb.finger->tcb) == -1){
  289.             printf(notval);
  290.             return 1;
  291.         }
  292.         break;
  293. #endif
  294. #ifdef NETROM
  295.     case NRSESSION:
  296.         if(kick_nr4(s->cb.nr4_cb) == -1) {
  297.             printf(notval) ;
  298.             return 1 ;
  299.         }
  300.         break ;
  301. #endif
  302.     }
  303.     return 0;
  304. }
  305. struct session *
  306. newsession()
  307. {
  308.     register int i;
  309.  
  310.     for(i=0;i<nsessions;i++)
  311.         if(sessions[i].type == FREE)
  312.             return &sessions[i];
  313.     return NULLSESSION;
  314. }
  315. freesession(s)
  316. struct session *s;
  317. {
  318.     if(s == NULLSESSION)
  319.         return;
  320.     if(s->record != NULLFILE){
  321.         fclose(s->record);
  322.         s->record = NULLFILE;
  323.     }
  324.     if(s->rfile != NULLCHAR){
  325.         free(s->rfile);
  326.         s->rfile = NULLCHAR;
  327.     }
  328.     if(s->upload != NULLFILE){
  329.         fclose(s->upload);
  330.         s->upload = NULLFILE;
  331.     }
  332.     if(s->ufile != NULLCHAR){
  333.         free(s->ufile);
  334.         s->ufile = NULLCHAR;
  335.     }
  336.     if(s->name != NULLCHAR){
  337.         free(s->name);
  338.         s->name = NULLCHAR;
  339.     }
  340.     s->type = FREE;
  341. }
  342. /* Control session recording */
  343. dorecord(argc,argv)
  344. int argc;
  345. char *argv[];
  346. {
  347.     if(current == NULLSESSION){
  348.         printf("No current session\n");
  349.         return 1;
  350.     }
  351.     if(argc > 1){
  352.         if(current->rfile != NULLCHAR){
  353.             fclose(current->record);
  354.             free(current->rfile);
  355.             current->record = NULLFILE;
  356.             current->rfile = NULLCHAR;
  357.         }
  358.         /* Open new record file, unless file name is "off", which means
  359.          * disable recording
  360.          */
  361.         if(strcmp(argv[1],"off") != 0
  362.          && (current->record = fopen(argv[1],"a")) != NULLFILE){
  363.             current->rfile = malloc((unsigned)strlen(argv[1])+1);
  364.             strcpy(current->rfile,argv[1]);
  365.         }
  366.     }
  367.     if(current->rfile != NULLCHAR)
  368.         printf("Recording into %s\n",current->rfile);
  369.     else
  370.         printf("Recording off\n");
  371.     return 0;
  372. }
  373. /* Control file transmission */
  374. doupload(argc,argv)
  375. int argc;
  376. char *argv[];
  377. {
  378.     struct tcb *tcb;
  379.     struct ax25_cb *axp;
  380. #ifdef NETROM
  381.     struct nr4cb *cb ;
  382. #endif
  383.  
  384.     if(current == NULLSESSION){
  385.         printf("No current session\n");
  386.         return 1;
  387.     }
  388.     if(argc > 1){
  389.         switch(current->type){
  390.         case TELNET:
  391.             tcb = current->cb.telnet->tcb;
  392.             break;
  393. #ifdef    AX25
  394.         case AX25TNC:
  395.             axp = current->cb.ax25_cb;
  396.             break;
  397. #endif
  398. #ifdef NETROM
  399.         case NRSESSION:
  400.             cb = current->cb.nr4_cb ;
  401.             break ;
  402. #endif
  403.         case FTP:
  404.             printf("Uploading on FTP control channel not supported\n");
  405.             return 1;
  406.         }
  407.         if(strcmp(argv[1],"stop") == 0 && current->upload != NULLFILE){
  408.             /* Abort upload */
  409.             fclose(current->upload);
  410.             current->upload = NULLFILE;
  411.             if(current->ufile != NULLCHAR){
  412.                 free(current->ufile);
  413.                 current->ufile = NULLCHAR;
  414.             }
  415.         }
  416.         /* Open upload file */
  417.         if((current->upload = fopen(argv[1],"r")) == NULLFILE){
  418.             printf("Can't read %s\n",argv[1]);
  419.             return 1;
  420.         }
  421.         current->ufile = malloc((unsigned)strlen(argv[1])+1);
  422.         strcpy(current->ufile,argv[1]);
  423.         /* All set, kick transmit upcall to get things rolling */
  424.         switch(current->type){
  425. #ifdef    AX25
  426.         case AX25TNC:
  427.             (*axp->t_upcall)(axp,axp->paclen * axp->maxframe);
  428.             break;
  429. #endif
  430. #ifdef NETROM
  431.         case NRSESSION:
  432.             (*cb->t_upcall)(cb, NR4MAXINFO) ;
  433.             break ;
  434. #endif
  435.         case TELNET:
  436.             (*tcb->t_upcall)(tcb,tcb->snd.wnd - tcb->sndcnt);
  437.             break;
  438.         }
  439.     }
  440.     if(current->ufile != NULLCHAR)
  441.         printf("Uploading %s\n",current->ufile);
  442.     else
  443.         printf("Uploading off\n");
  444.     return 0;
  445. }
  446.